home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 194_01 / pat.c < prev    next >
Text File  |  1985-11-13  |  6KB  |  274 lines
  1. /* [PAT.C of JUGPDS Vol.17]
  2. *****************************************************************
  3. *                                *
  4. *    Written by  Hakuo Katayose (JUG-CP/M No.179)        *
  5. *            49-114 Kawauchi-Sanjuunin-machi        *
  6. *            Sendai, Miyagi 980                          *
  7. *            Phone: 0222-61-3219                *
  8. *                                *
  9. *    Edited & tested by Y. Monma (JUG-C/M Disk Editor)       * 
  10. *                                *
  11. *****************************************************************
  12. */
  13.  
  14. /* pat - makepat and other functions to handle strings */
  15.  
  16. #include <bdscio.h>
  17. #include "def.h"
  18.  
  19. /* makpat - make pattern from arg[from], terminate at delim */
  20. makpat(arg, from, delim, pat)
  21. char    delim, arg[], pat[];
  22. int    from;
  23.  
  24. {
  25.     int    i, j, lastj, lastcl, lj, len, k, kk[10], dp;
  26.     char    c;
  27.  
  28.     j = 0; lastj = 0; lastcl = 0; k = '1'; dp = 0;
  29.     for (i = from; arg[i] != delim && arg[i] != EOS; i++) {
  30.         lj = j;
  31.         c = arg[i];
  32.         if (c == NPAT) {
  33.             addset(BPAT, pat, &j, MAXPAT);
  34.             addset(k, pat, &j, MAXPAT);
  35.             kk[dp++] = k++;
  36.             }
  37.         else if (c == NPATEND) {
  38.             addset(EPAT, pat, &j, MAXPAT);
  39.             addset(kk[--dp], pat, &j, MAXPAT);
  40.             }
  41.         else if (c == ANY) {
  42.             addset(ANY, pat, &j, MAXPAT);
  43.             }
  44.         else if (c == BOL && i ==from) {
  45.             addset(BOL, pat, &j, MAXPAT);
  46.             }
  47.         else if (c == EOL && arg[i+1] == delim) {
  48.             addset(EOL, pat, &j, MAXPAT);
  49.             }
  50.         else if (c == CCL) {
  51.             if (getccl(arg, &i, pat, &j) == ERROR) break;
  52.             }
  53.         else if ((c == CLOSURE || c == PLUS) && i > from) {
  54.             lj = lastj;
  55.             if (pat[lj] == BOL ||
  56.                 pat[lj] == EOL || 
  57.                 pat[lj] == CLOSURE)
  58.                 break;
  59.             if (c == PLUS) {
  60.                 len = j - lj;
  61.                 _copy(&pat[lj], &pat[j], len);
  62.                 j += len;
  63.                 lj += len;
  64.                 lastj += len;
  65.                 }
  66.             lastcl = stclos(pat, &j, lastj, lastcl);
  67.             }
  68.         else {
  69.             addset(CHAR, pat, &j, MAXPAT);
  70.             addset(esc(arg, &i), pat, &j, MAXPAT);
  71.             }
  72.         lastj = lj;
  73.         }
  74.     if (arg[i] != delim)
  75.         return ERROR;
  76.     if (j >= MAXPAT)
  77.         return ERROR;
  78.     if (dp < 0)
  79.         return ERROR;
  80.     pat[j] = EOS;
  81.     return(k - '1');
  82. }
  83.  
  84.  
  85. _copy(s, d, l)
  86. char    *s, *d;
  87. int    l;
  88.  
  89. {
  90.     int    i;
  91.  
  92.     for (i=0; i < l; i++)
  93.         *d++ = *s++;
  94.     return;
  95. }
  96.  
  97. /* getccl - expand char class at arg[i] into pat[j] */
  98. getccl(arg, i, pat, j)
  99. char    arg[], pat[];
  100. int    *i, *j;
  101.  
  102. {
  103.     int    jstart;
  104.  
  105.     (*i)++;
  106.     if (arg[*i] == NOT) {
  107.         pat[(*j)++] = NCCL;
  108.         (*i)++;
  109.         }
  110.     else
  111.         pat[(*j)++] = CCL;
  112.     jstart = *j;
  113.     addset(0, pat, j, MAXPAT);
  114.     filset(CCLEND, arg, i, pat, j, MAXPAT);
  115.     pat[jstart] = (*j) - jstart - 1;
  116.     return (arg[*i] == CCLEND) ? OK : ERROR;
  117. }
  118.  
  119. /* stclos - insert closure entry at pat[j] */
  120. stclos(pat, j, lastj, lastcl)
  121. char    pat[];
  122. int    *j, lastj, lastcl;
  123.  
  124. {
  125.     int    jt, jp;
  126.  
  127.     for (jp = (*j) - 1; jp >= lastj; jp--) {
  128.         jt = jp + CLOSIZE;
  129.         addset(pat[jp], pat, &jt, MAXPAT);
  130.         }
  131.     (*j) += CLOSIZE;
  132.     jp = lastj;
  133.     addset(CLOSURE, pat, &lastj, MAXPAT);
  134.     addset(0, pat, &lastj, MAXPAT);
  135.     addset(lastcl, pat, &lastj, MAXPAT);
  136.     addset(0, pat, &lastj, MAXPAT);
  137.     return jp;
  138. }
  139.  
  140. /* filset - expand set at array[i] into set[j], stop at delim */ 
  141. filset(delim, array, i, set, j, maxsiz)
  142. int    *i, *j, maxsiz;
  143. char    array[], delim, set[];
  144.  
  145. {
  146.     char    *digits, *lowalf, *upalf, c;
  147.  
  148.     digits = "0123456789";
  149.     lowalf = "abcdefghijklmnopqrstuvwxyz";
  150.     upalf  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  151.     for (; (c = array[*i]) != delim && c != EOS; (*i)++)
  152.         if (c == ESCAPE || c == UPALLOW)
  153.             addset(esc(array, i), set, j, maxsiz);
  154.         else if (c != DASH)
  155.             addset(tolower(c), set, j, maxsiz);
  156.         else if (*j == 0 || array[(*i)+1] == EOS)
  157.             addset(DASH, set, j, maxsiz);
  158.         else if (cindex(digits, set[(*j)-1]) >= 0)
  159.             dodash(digits, array, i, set, j, maxsiz);
  160.         else if (cindex(lowalf, set[(*j)-1]) >= 0)
  161.             dodash(lowalf, array, i, set,j, maxsiz);
  162.         else if (cindex(upalf, set[(*j)-1]) >= 0)
  163.             dodash(upalf, array, i, set, j, maxsiz);
  164.         else
  165.             addset(DASH, set, j, maxsiz);
  166.     return;
  167. }
  168.  
  169. /* esc - map array[i] into escaped charaters if appropriate */
  170. esc(array, i)
  171. int    *i;
  172. char    array[];
  173.  
  174. {
  175.     char    c;
  176.  
  177.     c = tolower(array[*i]);
  178.     if (c == UPALLOW && isalpha(array[(*i)+1])) {
  179.         c = array[++(*i)];
  180.         return(toupper(c));
  181.         }
  182.     if (c != ESCAPE)
  183.         return(c);
  184.     if (array[(*i)+1] == EOS)
  185.         return(ESCAPE);
  186.     c = array[++(*i)];
  187.     c = tolower(c);
  188.     if (c == 'b')
  189.         return(BACKSPACE);
  190.     if (c == 'f')
  191.         return(FORMFEED);
  192.     if (c == 'n')
  193.         return(NEWLINE);
  194.     if (c == 'r')
  195.         return(CRETURN);
  196.     if (c == 's')
  197.         return(BLANK);
  198.     if (c == 't')
  199.         return(TAB);
  200.     return(c);
  201. }
  202.  
  203. /* dodash - expand array[i-1] -array[i+1] into set[j]...from valid */
  204. dodash(valid, array, i, set, j, maxsiz)
  205. int    *i, *j, maxsiz;
  206. char    array[], set[], valid[];
  207.  
  208. {
  209.     int    k, limit;
  210.  
  211.     (*i)++;
  212.     (*j)--;
  213.     limit = cindex(valid, esc(array, i));
  214.     for (k = cindex(valid, set[*j]); k <= limit; k++)
  215.         addset(valid[k], set, j, maxsiz);
  216. }
  217.  
  218. /* addset - put c in set[j] if it fits, increment j */
  219. addset(c, set, j, maxsiz)
  220. char    c, set[];
  221. int    *j, maxsiz;
  222.  
  223. {
  224.     if (*j > maxsiz)
  225.         return(NO);
  226.     set[(*j)++] = c;
  227.     return(YES);
  228. }
  229.  
  230. /* xindex - invert condition returned by index */
  231. xindex(array, c, allbut, lastto)
  232. char    array[];
  233. int    c, allbut, lastto;
  234.  
  235. {
  236.     if (c == EOF)
  237.         return(ERROR);
  238.     if (allbut == NO)
  239.         return(cindex(array,c));
  240.     if (cindex(array,c) >= 0)
  241.         return(ERROR);
  242.     return(++lastto);
  243. }
  244.  
  245. /* cindex - find character c in string str */ 
  246. cindex(str, c)
  247. char    *str;
  248. int    c;
  249.  
  250. {
  251.     int    i;
  252.     i = 0;
  253.     while(*str && *str != c) *str++, i++;
  254.     return (*str == 0 ? ERROR : i);
  255. }
  256.  
  257. /* getlin - copy line */
  258. getlin(s, lim)
  259. char    *s;
  260. int    lim;
  261.  
  262. {
  263.     char    *p;
  264.     int    c;
  265.  
  266.     p = s;
  267.     while (--lim > 0 && (c = getchar()) != EOF && c != NEWLINE)
  268.         *s++ = c;
  269.     if (c == NEWLINE)
  270.         *s++ = c;
  271.     *s = EOS;
  272.     return(s-p);
  273. }
  274.